// Zombie Monster for KF Invasion gametype
class DKFleshpound extends DKFleshpoundBase;

var float RageStartTime;

var   sound   BeepSound;

#exec OBJ LOAD FILE=PlayerSounds.uax

//----------------------------------------------------------------------------
// NOTE: All Variables are declared in the base class to eliminate hitching
//----------------------------------------------------------------------------

var() float ExplosiveDmgScale;
var		bool	bSuicidal,bBeginSelfDestruct,bSelfDestruct;
var		float	TrySelfDestructTime,BeepSoundTime,BeepSoundFreq;

replication
{
	reliable if ( Role == ROLE_Authority )
		bBeginSelfDestruct,
		bSelfDestruct;
}

simulated function PostBeginPlay()
{
	Super.PostBeginPlay();
		
	if( bDoubled )
	{
		ExplosiveDmgScale *= 2.0;
	}
	
	if ( FRand() < 0.10 )
	{
		bSuicidal = true;
	}
}

simulated function PostNetBeginPlay()
{
	if (AvoidArea == None)
		AvoidArea = Spawn(class'FleshPoundAvoidArea',self);
	if (AvoidArea != None)
		AvoidArea.InitFor(Self);

	EnableChannelNotify ( 1,1);
	AnimBlendParams(1, 1.0, 0.0,, SpineBone1);
	super.PostNetBeginPlay();
}

// This zed has been taken control of. Boost its health and speed
function SetMindControlled(bool bNewMindControlled)
{
    if( bNewMindControlled )
    {
        NumZCDHits++;

        // if we hit him a couple of times, make him rage!
        if( NumZCDHits > 1 )
        {
            if( !IsInState('ChargeToMarker') )
            {
                GotoState('ChargeToMarker');
            }
            else
            {
                NumZCDHits = 1;
                if( IsInState('ChargeToMarker') )
                {
                    GotoState('');
                }
            }
        }
        else
        {
            if( IsInState('ChargeToMarker') )
            {
                GotoState('');
            }
        }

        if( bNewMindControlled != bZedUnderControl )
        {
            GroundSpeed = OriginalGroundSpeed * 1.25;
    		Health *= 1.25;
    		HealthMax *= 1.25;
		}
    }
    else
    {
        NumZCDHits=0;
    }

    bZedUnderControl = bNewMindControlled;
}

// Handle the zed being commanded to move to a new location
function GivenNewMarker()
{
    if( bChargingPlayer && NumZCDHits > 1  )
    {
        GotoState('ChargeToMarker');
    }
    else
    {
        GotoState('');
    }
}

// Important Block of code controlling how the Zombies (excluding the Bloat and Fleshpound who cannot be stunned, respond to damage from the
// various weapons in the game. The basic rule is that any damage amount equal to or greater than 40 points will cause a stun.
// There are exceptions with the fists however, which are substantially under the damage quota but can still cause stuns 50% of the time.
// Why? Cus if they didn't at least have that functionality, they would be fundamentally useless. And anyone willing to take on a hoarde of zombies
// with only the gloves on his hands, deserves more respect than that!
function PlayTakeHit(vector HitLocation, int Damage, class<DamageType> DamageType)
{
	if( Level.TimeSeconds - LastPainAnim < MinTimeBetweenPainAnims )
		return;

    // Don't interrupt the controller if its waiting for an animation to end
    if( !Controller.IsInState('WaitForAnim') && Damage >= 10 )
        PlayDirectionalHit(HitLocation);

	LastPainAnim = Level.TimeSeconds;

	if( Level.TimeSeconds - LastPainSound < MinTimeBetweenPainSounds )
		return;

	LastPainSound = Level.TimeSeconds;
	PlaySound(HitSound[0], SLOT_Pain,1.25,,400);
}

function TakeDamage( int Damage, Pawn InstigatedBy, Vector Hitlocation, Vector Momentum, class<DamageType> damageType, optional int HitIndex)
{
	local int BlockSlip, OldHealth;
	local float BlockChance;//, RageChance;
	
	OldHealth = Health; // Corrected issue where only the Base Health is counted toward the FP's Rage in Balance Round 6(second attempt)
	
	if ( class<DamTypeFrag>(DamageType) != none && class<DamTypeLAW>(DamageType) == none || DamageType == class 'DamTypePipeBomb'
		|| DamageType == class 'DamTypeM203Nade' || DamageType == class 'DamTypeRadioBomb' )
	{
		Damage *= 2.0 * ExplosiveDmgScale;
	}
	else if( DamageType == class 'DamTypeM79Grenade' || DamageType == class 'DamTypeM32Grenade' || DamageType == class 'DamTypeEX41' )
	{
		Damage *= 1.25 * ExplosiveDmgScale;
	}
	else if( class<DamTypeLAW>(DamageType) != none )
	{
		Damage *= ExplosiveDmgScale;
	}
	else if( DamageType == class 'DamTypeRPG' )
	{
		Damage *= 1.357 * ExplosiveDmgScale;
	}

	if( Level.Game.GameDifficulty < 5 || Frand() > ChanceToBlockDamage || class<DamTypeM32Grenade>(damageType) != none || class<DamTypeM79Grenade>(damageType) != none ||
		class<DamTypeFrag>(damageType) != none || class<DamTypeLAW>(damageType) != none || class<DamTypeRocketImpact>(damageType) != none ||
		class<DamTypeLawRocketImpact>(damageType) != none || class<DamTypePipeBomb>(damageType) != none || class<DamTypeStun>(damageType) != none ||
		(class<KFWeaponDamageType>(damageType) != none && class<KFWeaponDamageType>(damageType).default.bIsMeleeDamage) || class<DamTypeRPG>(damageType) != none  )

		Super.takeDamage(Damage, instigatedBy, hitLocation, momentum, damageType, HitIndex);

	else if ( class<DamTypeFlamethrower>(damageType) != none || class<DamTypeFlameNade>(damageType) != none ||
			  class<DamTypeBurned>(damageType) != none )
	{
		Damage *= 0.18;
		Super.takeDamage(Damage, instigatedBy, hitLocation, momentum, damageType, HitIndex);
	}
	if ( DamageType == class'DamTypeAxe' || DamageType == class'DamTypeAxeAltAttack' )
	{
		TwoSecondDamageTotal += FMin(RageDamageThreshold-10,OldHealth-Health);
	}
	else
	{
		TwoSecondDamageTotal += OldHealth - Health; // Corrected issue where only the Base Health is counted toward the FP's Rage in Balance Round 6(second attempt)
	}

	if( class<DamTypeStun>(damageType) != none )
	{
		bChargingPlayer = False;
        bFrustrated = false;
		RageEndTime = 0;
		FleshpoundBZombieController(Controller).RageFrustrationTimer = 0;
        GotoState('');
	}
	else
	if (!bDecapitated && AbilityEnabled("Rage") && TwoSecondDamageTotal > RageDamageThreshold && !bChargingPlayer &&
        (!(bCrispified && bBurnified) || bFrustrated) )
		StartCharging();

}

function int SetResist(int Damage, Pawn InstigatedBy, Vector HitLocation, Vector Momentum, class<DamageType> DamageType)
{
	local bool bIsHeadshot;
	local float HeadShotCheckScale;

	DKGameType(Level.Game).DebugMessage("Set resist: Incoming Damage = " $ string(Damage));

	if( LastDamagedTime<Level.TimeSeconds )
		TwoSecondDamageTotal = 0;
	LastDamagedTime = Level.TimeSeconds+2;

    HeadShotCheckScale = 1.0;

    // Do larger headshot checks if it is a melee attach
    if( class<DamTypeMelee>(damageType) != none )
    {
        HeadShotCheckScale *= 1.25;
    }

    bIsHeadShot = IsHeadShot(Hitlocation, normal(Momentum), 1.0);
	
//	if ( class<DamTypeSilent>(DamageType) != none )
//	{
//		Damage *= 0.50;
//	}
	
	if ( bIsHeadshot )
	{
		if ( class<DamTypeSVDcHeadShot>(DamageType) != none )
		{
			Damage *= 0.55;
		}
		else if ( class<DamTypeVSSDT>(DamageType) != none )
		{
			Damage *= 0.70;
		}
		else if ( class<DamTypeCrossbowHeadShot>(DamageType) != none )
		{
			Damage *= 0.80;
		}
		else if ( class<DamTypeHK417SR>(DamageType) != none )
		{
			Damage *= 1.05;
		}
		else if ( class<DamTypeM99SR>(DamageType) != none )
		{
			Damage *= 0.80;
		}
		else if ( class<DamTypeSilentCrossbow>(damageType) != none )
		{
			Damage *= 0.35;
			DKGameType(Level.Game).DebugMessage("Set resist: Silent Crossbow Damage = " $ string(Damage));
		}
		else if ( class<DamTypeBlackChainsaw>(DamageType) != none )
		{
			Damage *= 1.20;
		}
		else if( class<KFWeaponDamageType>(damageType)!=none && class<KFWeaponDamageType>(damageType).default.HeadShotDamageMult >= 1.5 )
		{
			Damage *= 0.75;
		}
		else
		{
			Damage *= 0.50;
		}
	}
	else
	{
		DKGameType(Level.Game).DebugMessage("Comparison : Damage = " $ string(Damage));
		if ( DamageType == class 'DamTypePP19SG' )
		{
			Damage *= 0.25;
		}
		else if ( DamageType == class 'DamTypeBurned' || DamageType == class 'DamTypeFlameNade' || DamageType == class 'DamTypeFireField'
				|| DamageType == class 'DamTypeFlameLauncher' || DamageType == class 'DamTypeFlare' )
		{
			Damage *= 0.20 * ( 1.0 - DKGameType(Level.Game).ProfResist );
		}
		else if( DamageType == class'DamTypeBlackChainsaw' )
		{
			Damage *= 0.8;
		}
		else if ( class<KFWeaponDamageType>(DamageType).default.bIsMeleeDamage )
		{
			Damage *= 0.5;
			DKGameType(Level.Game).DebugMessage("Melee Damage = " $ string(Damage));
		}
		else if ( DamageType == class 'DamTypePoundCrushed' || DamageType == class 'DamTypeVomit' )
		{
			Damage = 0;
		}
		else if ( class<DamTypeMG>(damageType).default.bIsMG )
		{
			Damage *= 0.75;
		}
		else
		{
			Damage *= 0.5 * ( 1.0 - DKGameType(Level.Game).ProfResist );
		}
		DKGameType(Level.Game).DebugMessage("Comparison ended : Damage = " $ string(Damage));
	}

	// Shut off his "Device" when dead
	if (Damage >= Health)
		PostNetReceive();

	DKGameType(Level.Game).DebugMessage("Set resist: Damage = " $ string(Damage));

	return Super.SetResist(Damage, instigatedBy, hitLocation, momentum, damageType);
}

// changes colors on Device (notified in anim)
simulated function DeviceGoRed()
{
    Skins[1]=Shader'KFCharacters.FPRedBloomShader';
}

simulated function DeviceGoNormal()
{
    Skins[1] = Shader'KFCharacters.FPAmberBloomShader';
}

function RangedAttack(Actor A)
{
	if ( bShotAnim || Physics == PHYS_Swimming)
		return;
	else if ( CanAttack(A) )
	{
		bShotAnim = true;
		SetAnimAction('Claw');
		//PlaySound(sound'Claw2s', SLOT_None); KFTODO: Replace this
		return;
	}
}

simulated function StartSelfDestruct()
{
	if ( health <= 0 )
	{
		return;
	}
	bBeginSelfDestruct = true;
	StartCharging();
}

// Sets the FP in a berserk charge state until he either strikes his target, or hits timeout
function StartCharging()
{
    local float RageAnimDur;
	
	if ( bDesorientated )
		return;

	KFGameType(Level.Game).DramaticEvent(0.075);
	SetAnimAction('PoundRage');
	Acceleration = vect(0,0,0);
	bShotAnim = true;
	Velocity.X = 0;
	Velocity.Y = 0;
	Controller.GoToState('WaitForAnim');
	KFMonsterController(Controller).bUseFreezeHack = True;
	RageAnimDur = GetAnimDuration('PoundRage');
    FleshpoundZombieController(Controller).SetPoundRageTimout(RageAnimDur);
	GoToState('BeginRaging');
}

state BeginRaging
{
    Ignores StartCharging,StartSelfDestruct;

    function bool CanGetOutOfWay()
    {
        return false;
    }

    simulated function bool HitCanInterruptAction()
    {
        return false;
    }

	function Tick( float Delta )
	{
        Acceleration = vect(0,0,0);

        global.Tick(Delta);
	}

Begin:
    Sleep(GetAnimDuration('PoundRage'));
	if ( bBeginSelfDestruct )
	{
		bBeginSelfDestruct = false;
		bSelfDestruct = true;
	}
	else
	{
		GotoState('RageCharging');
	}
}


simulated function SetBurningBehavior()
{
    if( bFrustrated || bChargingPlayer )
    {
        return;
    }

    super.SetBurningBehavior();
}

state RageCharging
{
Ignores StartCharging,StartSelfDestruct;

    function PlayDirectionalHit(Vector HitLoc)
    {
        if( !bShotAnim )
        {
            super.PlayDirectionalHit(HitLoc);
        }
    }

    function bool CanGetOutOfWay()
    {
        return false;
    }

	function BeginState()
	{
		RageStartTime = Level.TimeSeconds;
		MonsterReplicationInfo(Controller.PlayerReplicationInfo).ChargeStartTime = Level.TimeSeconds;
		
		DesorientationResist = 1.0 - (1.0 - default.DesorientationResist) * 0.5;

        bChargingPlayer = true;
		if( Level.NetMode!=NM_DedicatedServer )
			ClientChargingAnims();

		SetRageEndTime();
		NetUpdateTime = Level.TimeSeconds - 1;
	}

	function EndState()
	{
        bChargingPlayer = False;
        bFrustrated = false;
		DesorientationResist = default.DesorientationResist;
		TwoSecondDamageTotal = 0;
		RageSpeedMod = 1.00;

        FleshPoundZombieController(Controller).RageFrustrationTimer = 0;
		

		if( Health>0 )
		{
			UpdateMovementSpeed();
		}

		if( Level.NetMode!=NM_DedicatedServer )
			ClientChargingAnims();

		NetUpdateTime = Level.TimeSeconds - 1;
	}

	function Tick( float Delta )
	{
		if( !bShotAnim )
		{
			RageSpeedMod = 2.3;
			UpdateMovementSpeed();
			if( !bFrustrated && !bZedUnderControl && Level.TimeSeconds>RageEndTime )
			{
            	GoToState('');
			}
		}

        // Keep the flesh pound moving toward its target when attacking
    	if( Role == ROLE_Authority && bShotAnim)
    	{
    		if( LookTarget!=None )
    		{
    		    Acceleration = AccelRate * Normal(LookTarget.Location - Location);
    		}
        }

        global.Tick(Delta);
	}

	function Bump( Actor Other )
	{
        local float RageBumpDamage;
        local KFMonster KFMonst;

        KFMonst = KFMonster(Other);

        // Hurt/Kill enemies that we run into while raging
        if( !bShotAnim && KFMonst!=None && ( DKFleshpound(Other)==None || ZombieFleshPound(Other)==None ) && Pawn(Other).Health>0 )
		{
			// Random chance of doing obliteration damage
            if( FRand() < 0.4 )
			{
			     RageBumpDamage = 501;
			}
			else
			{
			     RageBumpDamage = 450;
			}

			RageBumpDamage *= KFMonst.PoundRageBumpDamScale;

			Other.TakeDamage(RageBumpDamage, self, Other.Location, Velocity * Other.Mass, class'DamTypePoundCrushed');
		}
		else Global.Bump(Other);
	}
	// If fleshie hits his target on a charge, then he should settle down for abit.
	function bool MeleeDamageTarget(int hitdamage, vector pushdir)
	{
		local bool RetVal,bWasEnemy;

		bWasEnemy = (Controller.Target==Controller.Enemy);
		RetVal = Super.MeleeDamageTarget(hitdamage*1.75, pushdir*3);
		if( RetVal && bWasEnemy )
			GoToState('');
		return RetVal;
	}
}

// State where the zed is charging to a marked location.
// Not sure if we need this since its just like RageCharging,
// but keeping it here for now in case we need to implement some
// custom behavior for this state
state ChargeToMarker extends RageCharging
{
Ignores StartCharging,StartSelfDestruct;

	function Tick( float Delta )
	{
		if( !bShotAnim )
		{
			RageSpeedMod = 2.3;
			UpdateMovementSpeed();
			if( !bFrustrated && !bZedUnderControl && Level.TimeSeconds>RageEndTime )
			{
            	GoToState('');
			}
		}

        // Keep the flesh pound moving toward its target when attacking
    	if( Role == ROLE_Authority && bShotAnim)
    	{
    		if( LookTarget!=None )
    		{
    		    Acceleration = AccelRate * Normal(LookTarget.Location - Location);
    		}
        }

        global.Tick(Delta);
	}
}

simulated function PostNetReceive()
{
	if( bClientCharge!=bChargingPlayer )
	{
		bClientCharge = bChargingPlayer;
		if (bChargingPlayer)
		{
			MovementAnims[0]=ChargingAnim;
			MeleeAnims[0]='FPRageAttack';
			MeleeAnims[1]='FPRageAttack';
			MeleeAnims[2]='FPRageAttack';
			DeviceGoRed();
		}
		else
		{
			MovementAnims[0]=default.MovementAnims[0];
			MeleeAnims[0]=default.MeleeAnims[0];
			MeleeAnims[1]=default.MeleeAnims[1];
			MeleeAnims[2]=default.MeleeAnims[2];
			DeviceGoNormal();
		}
	}
}

simulated function PlayDyingAnimation(class<DamageType> DamageType, vector HitLoc)
{
	Super.PlayDyingAnimation(DamageType,HitLoc);
	if( Level.NetMode!=NM_DedicatedServer )
		DeviceGoNormal();
}

simulated function ClientChargingAnims()
{
	PostNetReceive();
}

function ClawDamageTarget()
{
	local vector PushDir;
	local KFHumanPawn HumanTarget;
	local KFPlayerController HumanTargetController;
	local float UsedMeleeDamage;
	local name  Sequence;
	local float Frame, Rate;

	GetAnimParams( ExpectingChannel, Sequence, Frame, Rate );

	if( MeleeDamage > 1 )
    {
	   UsedMeleeDamage = (MeleeDamage - (MeleeDamage * 0.05)) + (MeleeDamage * (FRand() * 0.1));
	}
	else
	{
	   UsedMeleeDamage = MeleeDamage;
	}

    // Reduce the melee damage for anims with repeated attacks, since it does repeated damage over time
    if( Sequence == 'PoundAttack1' )
    {
        UsedMeleeDamage *= 0.5;
    }
    else if( Sequence == 'PoundAttack2' )
    {
        UsedMeleeDamage *= 0.25;
    }

	if(Controller!=none && Controller.Target!=none)
	{
		//calculate based on relative positions
		PushDir = (damageForce * Normal(Controller.Target.Location - Location));
	}
	else
	{
		//calculate based on way Monster is facing
		PushDir = damageForce * vector(Rotation);
	}
	if ( MeleeDamageTarget( UsedMeleeDamage, PushDir))
	{
		HumanTarget = KFHumanPawn(Controller.Target);
		if( HumanTarget!=None )
			HumanTargetController = KFPlayerController(HumanTarget.Controller);
		if( HumanTargetController!=None )
			HumanTargetController.ShakeView(RotMag, RotRate, RotTime, OffsetMag, OffsetRate, OffsetTime);
		PlaySound(MeleeAttackHitSound, SLOT_Interact, 1.25);
	}
}

function SpinDamage(actor Target)
{
	local vector HitLocation;
	local Name TearBone;
	local Float dummy;
	local float DamageAmount;
	local vector PushDir;
	local KFHumanPawn HumanTarget;

	if(target==none)
		return;

	PushDir = (damageForce * Normal(Target.Location - Location));
	damageamount = (SpinDamConst + rand(SpinDamRand) );

	// FLING DEM DEAD BODIEZ!
	if (Target.IsA('KFHumanPawn') && Pawn(Target).Health <= DamageAmount)
	{
		KFHumanPawn(Target).RagDeathVel *= 3;
		KFHumanPawn(Target).RagDeathUpKick *= 1.5;
	}

	if (Target !=none && Target.IsA('KFDoorMover'))
	{
		Target.TakeDamage(DamageAmount , self ,HitLocation,pushdir, class 'KFmod.ZombieMeleeDamage');
		PlaySound(MeleeAttackHitSound, SLOT_Interact, 1.25);
	}

	if (KFHumanPawn(Target)!=none)
	{
		HumanTarget = KFHumanPawn(Target);
		if (HumanTarget.Controller != none)
			HumanTarget.Controller.ShakeView(RotMag, RotRate, RotTime, OffsetMag, OffsetRate, OffsetTime);

		//TODO - line below was KFPawn. Does this whole block need to be KFPawn, or is it OK as KFHumanPawn?
		KFHumanPawn(Target).TakeDamage(DamageAmount, self ,HitLocation,pushdir, class 'KFmod.ZombieMeleeDamage');

		if (KFHumanPawn(Target).Health <=0)
		{
			KFHumanPawn(Target).SpawnGibs(rotator(pushdir), 1);
			TearBone=KFPawn(Target).GetClosestBone(HitLocation,Velocity,dummy);
			KFHumanPawn(Controller.Target).HideBone(TearBone);
		}
	}
}

simulated function int DoAnimAction( name AnimName )
{
	if( AnimName=='PoundAttack1' || AnimName=='PoundAttack2' || AnimName=='PoundAttack3'
        ||AnimName=='FPRageAttack' || AnimName=='ZombieFireGun' )
	{
		AnimBlendParams(1, 1.0, 0.0,, FireRootBone);
		PlayAnim(AnimName,, 0.1, 1);
		Return 1;
	}
	Return Super.DoAnimAction(AnimName);
}

simulated event SetAnimAction(name NewAction)
{
	local int meleeAnimIndex;

	if( NewAction=='' )
		Return;
	if(NewAction == 'Claw')
	{
		meleeAnimIndex = Rand(3);
		NewAction = meleeAnims[meleeAnimIndex];
		CurrentDamtype = ZombieDamType[meleeAnimIndex];
	}
	else if( NewAction == 'DoorBash' )
	{
	   CurrentDamtype = ZombieDamType[Rand(3)];
	}
	ExpectingChannel = DoAnimAction(NewAction);

    if( AnimNeedsWait(NewAction) )
    {
        bWaitForAnim = true;
    }

	if( Level.NetMode!=NM_Client )
	{
		AnimAction = NewAction;
		bResetAnimAct = True;
		ResetAnimActTime = Level.TimeSeconds+0.3;
	}
}

// The animation is full body and should set the bWaitForAnim flag
simulated function bool AnimNeedsWait(name TestAnim)
{
    if( TestAnim == 'PoundRage' || TestAnim == 'DoorBash' )
    {
        return true;
    }

    return false;
}

simulated function Tick(float DeltaTime)
{
    super.Tick(DeltaTime);
	
	if ( TrySelfDestructTime < Level.TimeSeconds && health < 0.40 )
	{
		if ( bSuicidal || FRand() < 0.04 )
		{
			StartSelfDestruct();
		}
	}
	
	if ( BeepSoundTime < Level.TimeSeconds && bBeginSelfDestruct )
	{
		BeepSoundTime = Level.TimeSeconds + BeepSoundFreq;
		PlaySound(BeepSound,SLOT_Misc,2.0,,150.0);
	}
	
	if ( bSelfDestruct )
	{
		Spawn(class'FleshpoundExplosion',Self,,Self.Location,rot(0,0,0)).Instigator = Self;
	}
	
	if ( bDesorientated )
	{
		LastDamagedTime = 0;
		BruteZombieController(Controller).RageFrustrationTimer = 0;
	}
	
	if ( LastDamagedTime < Level.TimeSeconds )
		TwoSecondDamageTotal = 0;

    // Keep the flesh pound moving toward its target when attacking
	if( Role == ROLE_Authority && bShotAnim)
	{
		if( LookTarget!=None )
		{
		    Acceleration = AccelRate * Normal(LookTarget.Location - Location);
		}
    }
}


function bool FlipOver()
{
	Return False;
}

function bool SameSpeciesAs(Pawn P)
{
	return (DKFleshpound(P)!=None);
}

simulated function Destroyed()
{
	if( AvoidArea!=None )
		AvoidArea.Destroy();

	Super.Destroyed();
}

simulated function SetRageEndTime()
{
	local float DifficultyModifier;

	// Scale rage length by difficulty
    if( Level.Game.GameDifficulty < 2.0 )
    {
        DifficultyModifier = 1.0;
	}
	else if( Level.Game.GameDifficulty < 4.0 )
	{
		DifficultyModifier = 1.25;
	}
	else if ( Level.Game.GameDifficulty < 7.0 )
	{
		DifficultyModifier = 3.0; // Doubled Fleshpound Rage time for Suicidal and HoE in Balance Round 1
	}
	else
	{
		DifficultyModifier = 6.0;
	}
	RageEndTime = (Level.TimeSeconds + 5 * DifficultyModifier) + (FRand() * 6 * DifficultyModifier);
	MonsterReplicationInfo(Controller.PlayerReplicationInfo).ChargeEndTime = RageEndTime;
}

defaultproperties
{
	SeverityLevel = 160.00

    DetachedArmClass=Class'KFChar.SeveredArmPound'
    DetachedLegClass=Class'KFChar.SeveredLegPound'
    DetachedHeadClass=Class'KFChar.SeveredHeadPound'
    ControllerClass=Class'FleshpoundBZombieController'
	ExplosiveDmgScale=1.0;
	CrispUpLimit = 15;
	Priority = 400;
	bImportant = true
	BurningResist=0.50;
	KillzedRequestLimit = 3;
	NadeHurtSpeedRecoverRate = 0.06;
	
	bSuicidal = false
    BeepSound=Sound'KF_FoundrySnd.1Shot.Keypad_beep01'
}